home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 24 / AACD 24.iso / AACD / Programming / gcc-2.95.3-3 / info / g77.info-11 < prev    next >
Encoding:
GNU Info File  |  2001-07-15  |  50.2 KB  |  1,390 lines
  1. This is Info file f/g77.info, produced by Makeinfo version 1.68 from
  2. the input file ./f/g77.texi.
  3.  
  4. INFO-DIR-SECTION Programming
  5. START-INFO-DIR-ENTRY
  6. * g77: (g77).                  The GNU Fortran compiler.
  7. END-INFO-DIR-ENTRY
  8.    This file documents the use and the internals of the GNU Fortran
  9. (`g77') compiler.  It corresponds to the GCC-2.95 version of `g77'.
  10.  
  11.    Published by the Free Software Foundation 59 Temple Place - Suite 330
  12. Boston, MA 02111-1307 USA
  13.  
  14.    Copyright (C) 1995-1999 Free Software Foundation, Inc.
  15.  
  16.    Permission is granted to make and distribute verbatim copies of this
  17. manual provided the copyright notice and this permission notice are
  18. preserved on all copies.
  19.  
  20.    Permission is granted to copy and distribute modified versions of
  21. this manual under the conditions for verbatim copying, provided also
  22. that the sections entitled "GNU General Public License," "Funding for
  23. Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
  24. included exactly as in the original, and provided that the entire
  25. resulting derived work is distributed under the terms of a permission
  26. notice identical to this one.
  27.  
  28.    Permission is granted to copy and distribute translations of this
  29. manual into another language, under the above conditions for modified
  30. versions, except that the sections entitled "GNU General Public
  31. License," "Funding for Free Software," and "Protect Your Freedom--Fight
  32. `Look And Feel'", and this permission notice, may be included in
  33. translations approved by the Free Software Foundation instead of in the
  34. original English.
  35.  
  36.    Contributed by James Craig Burley (<craig@jcb-sc.com>).  Inspired by
  37. a first pass at translating `g77-0.5.16/f/DOC' that was contributed to
  38. Craig by David Ronis (<ronis@onsager.chem.mcgill.ca>).
  39.  
  40. 
  41. File: g77.info,  Node: Pedantic Compilation,  Next: Distensions,  Prev: Fortran 90,  Up: Other Dialects
  42.  
  43. Pedantic Compilation
  44. ====================
  45.  
  46.    The `-fpedantic' command-line option specifies that `g77' is to warn
  47. about code that is not standard-conforming.  This is useful for finding
  48. some extensions `g77' accepts that other compilers might not accept.
  49. (Note that the `-pedantic' and `-pedantic-errors' options always imply
  50. `-fpedantic'.)
  51.  
  52.    With `-fno-f90' in force, ANSI FORTRAN 77 is used as the standard
  53. for conforming code.  With `-ff90' in force, Fortran 90 is used.
  54.  
  55.    The constructs for which `g77' issues diagnostics when `-fpedantic'
  56. and `-fno-f90' are in force are:
  57.  
  58.    * Automatic arrays, as in
  59.  
  60.           SUBROUTINE X(N)
  61.           REAL A(N)
  62.           ...
  63.  
  64.      where `A' is not listed in any `ENTRY' statement, and thus is not
  65.      a dummy argument.
  66.  
  67.    * The commas in `READ (5), I' and `WRITE (10), J'.
  68.  
  69.      These commas are disallowed by FORTRAN 77, but, while strictly
  70.      superfluous, are syntactically elegant, especially given that
  71.      commas are required in statements such as `READ 99, I' and `PRINT
  72.      *, J'.  Many compilers permit the superfluous commas for this
  73.      reason.
  74.  
  75.    * `DOUBLE COMPLEX', either explicitly or implicitly.
  76.  
  77.      An explicit use of this type is via a `DOUBLE COMPLEX' or
  78.      `IMPLICIT DOUBLE COMPLEX' statement, for examples.
  79.  
  80.      An example of an implicit use is the expression `C*D', where `C'
  81.      is `COMPLEX(KIND=1)' and `D' is `DOUBLE PRECISION'.  This
  82.      expression is prohibited by ANSI FORTRAN 77 because the rules of
  83.      promotion would suggest that it produce a `DOUBLE COMPLEX'
  84.      result--a type not provided for by that standard.
  85.  
  86.    * Automatic conversion of numeric expressions to `INTEGER(KIND=1)'
  87.      in contexts such as:
  88.  
  89.         - Array-reference indexes.
  90.  
  91.         - Alternate-return values.
  92.  
  93.         - Computed `GOTO'.
  94.  
  95.         - `FORMAT' run-time expressions (not yet supported).
  96.  
  97.         - Dimension lists in specification statements.
  98.  
  99.         - Numbers for I/O statements (such as `READ (UNIT=3.2), I')
  100.  
  101.         - Sizes of `CHARACTER' entities in specification statements.
  102.  
  103.         - Kind types in specification entities (a Fortran 90 feature).
  104.  
  105.         - Initial, terminal, and incrementation parameters for
  106.           implied-`DO' constructs in `DATA' statements.
  107.  
  108.    * Automatic conversion of `LOGICAL' expressions to `INTEGER' in
  109.      contexts such as arithmetic `IF' (where `COMPLEX' expressions are
  110.      disallowed anyway).
  111.  
  112.    * Zero-size array dimensions, as in:
  113.  
  114.           INTEGER I(10,20,4:2)
  115.  
  116.    * Zero-length `CHARACTER' entities, as in:
  117.  
  118.           PRINT *, ''
  119.  
  120.    * Substring operators applied to character constants and named
  121.      constants, as in:
  122.  
  123.           PRINT *, 'hello'(3:5)
  124.  
  125.    * Null arguments passed to statement function, as in:
  126.  
  127.           PRINT *, FOO(,3)
  128.  
  129.    * Disagreement among program units regarding whether a given `COMMON'
  130.      area is `SAVE'd (for targets where program units in a single source
  131.      file are "glued" together as they typically are for UNIX
  132.      development environments).
  133.  
  134.    * Disagreement among program units regarding the size of a named
  135.      `COMMON' block.
  136.  
  137.    * Specification statements following first `DATA' statement.
  138.  
  139.      (In the GNU Fortran language, `DATA I/1/' may be followed by
  140.      `INTEGER J', but not `INTEGER I'.  The `-fpedantic' option
  141.      disallows both of these.)
  142.  
  143.    * Semicolon as statement separator, as in:
  144.  
  145.           CALL FOO; CALL BAR
  146.  
  147.    * Use of `&' in column 1 of fixed-form source (to indicate
  148.      continuation).
  149.  
  150.    * Use of `CHARACTER' constants to initialize numeric entities, and
  151.      vice versa.
  152.  
  153.    * Expressions having two arithmetic operators in a row, such as
  154.      `X*-Y'.
  155.  
  156.    If `-fpedantic' is specified along with `-ff90', the following
  157. constructs result in diagnostics:
  158.  
  159.    * Use of semicolon as a statement separator on a line that has an
  160.      `INCLUDE' directive.
  161.  
  162. 
  163. File: g77.info,  Node: Distensions,  Prev: Pedantic Compilation,  Up: Other Dialects
  164.  
  165. Distensions
  166. ===========
  167.  
  168.    The `-fugly-*' command-line options determine whether certain
  169. features supported by VAX FORTRAN and other such compilers, but
  170. considered too ugly to be in code that can be changed to use safer
  171. and/or more portable constructs, are accepted.  These are humorously
  172. referred to as "distensions", extensions that just plain look ugly in
  173. the harsh light of day.
  174.  
  175. * Menu:
  176.  
  177. * Ugly Implicit Argument Conversion::  Disabled via `-fno-ugly-args'.
  178. * Ugly Assumed-Size Arrays::           Enabled via `-fugly-assumed'.
  179. * Ugly Null Arguments::                Enabled via `-fugly-comma'.
  180. * Ugly Complex Part Extraction::       Enabled via `-fugly-complex'.
  181. * Ugly Conversion of Initializers::    Disabled via `-fno-ugly-init'.
  182. * Ugly Integer Conversions::           Enabled via `-fugly-logint'.
  183. * Ugly Assigned Labels::               Enabled via `-fugly-assign'.
  184.  
  185. 
  186. File: g77.info,  Node: Ugly Implicit Argument Conversion,  Next: Ugly Assumed-Size Arrays,  Up: Distensions
  187.  
  188. Implicit Argument Conversion
  189. ----------------------------
  190.  
  191.    The `-fno-ugly-args' option disables passing typeless and Hollerith
  192. constants as actual arguments in procedure invocations.  For example:
  193.  
  194.      CALL FOO(4HABCD)
  195.      CALL BAR('123'O)
  196.  
  197. These constructs can be too easily used to create non-portable code,
  198. but are not considered as "ugly" as others.  Further, they are widely
  199. used in existing Fortran source code in ways that often are quite
  200. portable.  Therefore, they are enabled by default.
  201.  
  202. 
  203. File: g77.info,  Node: Ugly Assumed-Size Arrays,  Next: Ugly Null Arguments,  Prev: Ugly Implicit Argument Conversion,  Up: Distensions
  204.  
  205. Ugly Assumed-Size Arrays
  206. ------------------------
  207.  
  208.    The `-fugly-assumed' option enables the treatment of any array with
  209. a final dimension specified as `1' as an assumed-size array, as if `*'
  210. had been specified instead.
  211.  
  212.    For example, `DIMENSION X(1)' is treated as if it had read
  213. `DIMENSION X(*)' if `X' is listed as a dummy argument in a preceding
  214. `SUBROUTINE', `FUNCTION', or `ENTRY' statement in the same program unit.
  215.  
  216.    Use an explicit lower bound to avoid this interpretation.  For
  217. example, `DIMENSION X(1:1)' is never treated as if it had read
  218. `DIMENSION X(*)' or `DIMENSION X(1:*)'.  Nor is `DIMENSION X(2-1)'
  219. affected by this option, since that kind of expression is unlikely to
  220. have been intended to designate an assumed-size array.
  221.  
  222.    This option is used to prevent warnings being issued about apparent
  223. out-of-bounds reference such as `X(2) = 99'.
  224.  
  225.    It also prevents the array from being used in contexts that disallow
  226. assumed-size arrays, such as `PRINT *,X'.  In such cases, a diagnostic
  227. is generated and the source file is not compiled.
  228.  
  229.    The construct affected by this option is used only in old code that
  230. pre-exists the widespread acceptance of adjustable and assumed-size
  231. arrays in the Fortran community.
  232.  
  233.    *Note:* This option does not affect how `DIMENSION X(1)' is treated
  234. if `X' is listed as a dummy argument only *after* the `DIMENSION'
  235. statement (presumably in an `ENTRY' statement).  For example,
  236. `-fugly-assumed' has no effect on the following program unit:
  237.  
  238.      SUBROUTINE X
  239.      REAL A(1)
  240.      RETURN
  241.      ENTRY Y(A)
  242.      PRINT *, A
  243.      END
  244.  
  245. 
  246. File: g77.info,  Node: Ugly Complex Part Extraction,  Next: Ugly Conversion of Initializers,  Prev: Ugly Null Arguments,  Up: Distensions
  247.  
  248. Ugly Complex Part Extraction
  249. ----------------------------
  250.  
  251.    The `-fugly-complex' option enables use of the `REAL()' and `AIMAG()'
  252. intrinsics with arguments that are `COMPLEX' types other than
  253. `COMPLEX(KIND=1)'.
  254.  
  255.    With `-ff90' in effect, these intrinsics return the unconverted real
  256. and imaginary parts (respectively) of their argument.
  257.  
  258.    With `-fno-f90' in effect, these intrinsics convert the real and
  259. imaginary parts to `REAL(KIND=1)', and return the result of that
  260. conversion.
  261.  
  262.    Due to this ambiguity, the GNU Fortran language defines these
  263. constructs as invalid, except in the specific case where they are
  264. entirely and solely passed as an argument to an invocation of the
  265. `REAL()' intrinsic.  For example,
  266.  
  267.      REAL(REAL(Z))
  268.  
  269. is permitted even when `Z' is `COMPLEX(KIND=2)' and `-fno-ugly-complex'
  270. is in effect, because the meaning is clear.
  271.  
  272.    `g77' enforces this restriction, unless `-fugly-complex' is
  273. specified, in which case the appropriate interpretation is chosen and
  274. no diagnostic is issued.
  275.  
  276.    *Note CMPAMBIG::, for information on how to cope with existing code
  277. with unclear expectations of `REAL()' and `AIMAG()' with
  278. `COMPLEX(KIND=2)' arguments.
  279.  
  280.    *Note RealPart Intrinsic::, for information on the `REALPART()'
  281. intrinsic, used to extract the real part of a complex expression
  282. without conversion.  *Note ImagPart Intrinsic::, for information on the
  283. `IMAGPART()' intrinsic, used to extract the imaginary part of a complex
  284. expression without conversion.
  285.  
  286. 
  287. File: g77.info,  Node: Ugly Null Arguments,  Next: Ugly Complex Part Extraction,  Prev: Ugly Assumed-Size Arrays,  Up: Distensions
  288.  
  289. Ugly Null Arguments
  290. -------------------
  291.  
  292.    The `-fugly-comma' option enables use of a single trailing comma to
  293. mean "pass an extra trailing null argument" in a list of actual
  294. arguments to an external procedure, and use of an empty list of
  295. arguments to such a procedure to mean "pass a single null argument".
  296.  
  297.    (Null arguments often are used in some procedure-calling schemes to
  298. indicate omitted arguments.)
  299.  
  300.    For example, `CALL FOO(,)' means "pass two null arguments", rather
  301. than "pass one null argument".  Also, `CALL BAR()' means "pass one null
  302. argument".
  303.  
  304.    This construct is considered "ugly" because it does not provide an
  305. elegant way to pass a single null argument that is syntactically
  306. distinct from passing no arguments.  That is, this construct changes
  307. the meaning of code that makes no use of the construct.
  308.  
  309.    So, with `-fugly-comma' in force, `CALL FOO()' and `I = JFUNC()'
  310. pass a single null argument, instead of passing no arguments as
  311. required by the Fortran 77 and 90 standards.
  312.  
  313.    *Note:* Many systems gracefully allow the case where a procedure
  314. call passes one extra argument that the called procedure does not
  315. expect.
  316.  
  317.    So, in practice, there might be no difference in the behavior of a
  318. program that does `CALL FOO()' or `I = JFUNC()' and is compiled with
  319. `-fugly-comma' in force as compared to its behavior when compiled with
  320. the default, `-fno-ugly-comma', in force, assuming `FOO' and `JFUNC' do
  321. not expect any arguments to be passed.
  322.  
  323. 
  324. File: g77.info,  Node: Ugly Conversion of Initializers,  Next: Ugly Integer Conversions,  Prev: Ugly Complex Part Extraction,  Up: Distensions
  325.  
  326. Ugly Conversion of Initializers
  327. -------------------------------
  328.  
  329.    The constructs disabled by `-fno-ugly-init' are:
  330.  
  331.    * Use of Hollerith and typeless constants in contexts where they set
  332.      initial (compile-time) values for variables, arrays, and named
  333.      constants--that is, `DATA' and `PARAMETER' statements, plus
  334.      type-declaration statements specifying initial values.
  335.  
  336.      Here are some sample initializations that are disabled by the
  337.      `-fno-ugly-init' option:
  338.  
  339.           PARAMETER (VAL='9A304FFE'X)
  340.           REAL*8 STRING/8HOUTPUT00/
  341.           DATA VAR/4HABCD/
  342.  
  343.    * In the same contexts as above, use of character constants to
  344.      initialize numeric items and vice versa (one constant per item).
  345.  
  346.      Here are more sample initializations that are disabled by the
  347.      `-fno-ugly-init' option:
  348.  
  349.           INTEGER IA
  350.           CHARACTER BELL
  351.           PARAMETER (IA = 'A')
  352.           PARAMETER (BELL = 7)
  353.  
  354.    * Use of Hollerith and typeless constants on the right-hand side of
  355.      assignment statements to numeric types, and in other contexts
  356.      (such as passing arguments in invocations of intrinsic procedures
  357.      and statement functions) that are treated as assignments to known
  358.      types (the dummy arguments, in these cases).
  359.  
  360.      Here are sample statements that are disabled by the
  361.      `-fno-ugly-init' option:
  362.  
  363.           IVAR = 4HABCD
  364.           PRINT *, IMAX0(2HAB, 2HBA)
  365.  
  366.    The above constructs, when used, can tend to result in non-portable
  367. code.  But, they are widely used in existing Fortran code in ways that
  368. often are quite portable.  Therefore, they are enabled by default.
  369.  
  370. 
  371. File: g77.info,  Node: Ugly Integer Conversions,  Next: Ugly Assigned Labels,  Prev: Ugly Conversion of Initializers,  Up: Distensions
  372.  
  373. Ugly Integer Conversions
  374. ------------------------
  375.  
  376.    The constructs enabled via `-fugly-logint' are:
  377.  
  378.    * Automatic conversion between `INTEGER' and `LOGICAL' as dictated by
  379.      context (typically implies nonportable dependencies on how a
  380.      particular implementation encodes `.TRUE.' and `.FALSE.').
  381.  
  382.    * Use of a `LOGICAL' variable in `ASSIGN' and assigned-`GOTO'
  383.      statements.
  384.  
  385.    The above constructs are disabled by default because use of them
  386. tends to lead to non-portable code.  Even existing Fortran code that
  387. uses that often turns out to be non-portable, if not outright buggy.
  388.  
  389.    Some of this is due to differences among implementations as far as
  390. how `.TRUE.' and `.FALSE.' are encoded as `INTEGER' values--Fortran
  391. code that assumes a particular coding is likely to use one of the above
  392. constructs, and is also likely to not work correctly on implementations
  393. using different encodings.
  394.  
  395.    *Note Equivalence Versus Equality::, for more information.
  396.  
  397. 
  398. File: g77.info,  Node: Ugly Assigned Labels,  Prev: Ugly Integer Conversions,  Up: Distensions
  399.  
  400. Ugly Assigned Labels
  401. --------------------
  402.  
  403.    The `-fugly-assign' option forces `g77' to use the same storage for
  404. assigned labels as it would for a normal assignment to the same
  405. variable.
  406.  
  407.    For example, consider the following code fragment:
  408.  
  409.      I = 3
  410.      ASSIGN 10 TO I
  411.  
  412. Normally, for portability and improved diagnostics, `g77' reserves
  413. distinct storage for a "sibling" of `I', used only for `ASSIGN'
  414. statements to that variable (along with the corresponding
  415. assigned-`GOTO' and assigned-`FORMAT'-I/O statements that reference the
  416. variable).
  417.  
  418.    However, some code (that violates the ANSI FORTRAN 77 standard)
  419. attempts to copy assigned labels among variables involved with `ASSIGN'
  420. statements, as in:
  421.  
  422.      ASSIGN 10 TO I
  423.      ISTATE(5) = I
  424.      ...
  425.      J = ISTATE(ICUR)
  426.      GOTO J
  427.  
  428. Such code doesn't work under `g77' unless `-fugly-assign' is specified
  429. on the command-line, ensuring that the value of `I' referenced in the
  430. second line is whatever value `g77' uses to designate statement label
  431. `10', so the value may be copied into the `ISTATE' array, later
  432. retrieved into a variable of the appropriate type (`J'), and used as
  433. the target of an assigned-`GOTO' statement.
  434.  
  435.    *Note:* To avoid subtle program bugs, when `-fugly-assign' is
  436. specified, `g77' requires the type of variables specified in
  437. assigned-label contexts *must* be the same type returned by `%LOC()'.
  438. On many systems, this type is effectively the same as
  439. `INTEGER(KIND=1)', while, on others, it is effectively the same as
  440. `INTEGER(KIND=2)'.
  441.  
  442.    Do *not* depend on `g77' actually writing valid pointers to these
  443. variables, however.  While `g77' currently chooses that implementation,
  444. it might be changed in the future.
  445.  
  446.    *Note Assigned Statement Labels (ASSIGN and GOTO): Assigned
  447. Statement Labels, for implementation details on assigned-statement
  448. labels.
  449.  
  450. 
  451. File: g77.info,  Node: Compiler,  Next: Other Dialects,  Prev: Language,  Up: Top
  452.  
  453. The GNU Fortran Compiler
  454. ************************
  455.  
  456.    The GNU Fortran compiler, `g77', supports programs written in the
  457. GNU Fortran language and in some other dialects of Fortran.
  458.  
  459.    Some aspects of how `g77' works are universal regardless of dialect,
  460. and yet are not properly part of the GNU Fortran language itself.
  461. These are described below.
  462.  
  463.    *Note: This portion of the documentation definitely needs a lot of
  464. work!*
  465.  
  466. * Menu:
  467.  
  468. * Compiler Limits::
  469. * Run-time Environment Limits::
  470. * Compiler Types::
  471. * Compiler Constants::
  472. * Compiler Intrinsics::
  473.  
  474. 
  475. File: g77.info,  Node: Compiler Limits,  Next: Run-time Environment Limits,  Up: Compiler
  476.  
  477. Compiler Limits
  478. ===============
  479.  
  480.    `g77', as with GNU tools in general, imposes few arbitrary
  481. restrictions on lengths of identifiers, number of continuation lines,
  482. number of external symbols in a program, and so on.
  483.  
  484.    For example, some other Fortran compiler have an option (such as
  485. `-NlX') to increase the limit on the number of continuation lines.
  486. Also, some Fortran compilation systems have an option (such as `-NxX')
  487. to increase the limit on the number of external symbols.
  488.  
  489.    `g77', `gcc', and GNU `ld' (the GNU linker) have no equivalent
  490. options, since they do not impose arbitrary limits in these areas.
  491.  
  492.    `g77' does currently limit the number of dimensions in an array to
  493. the same degree as do the Fortran standards--seven (7).  This
  494. restriction might be lifted in a future version.
  495.  
  496. 
  497. File: g77.info,  Node: Run-time Environment Limits,  Next: Compiler Types,  Prev: Compiler Limits,  Up: Compiler
  498.  
  499. Run-time Environment Limits
  500. ===========================
  501.  
  502.    As a portable Fortran implementation, `g77' offers its users direct
  503. access to, and otherwise depends upon, the underlying facilities of the
  504. system used to build `g77', the system on which `g77' itself is used to
  505. compile programs, and the system on which the `g77'-compiled program is
  506. actually run.  (For most users, the three systems are of the same
  507. type--combination of operating environment and hardware--often the same
  508. physical system.)
  509.  
  510.    The run-time environment for a particular system inevitably imposes
  511. some limits on a program's use of various system facilities.  These
  512. limits vary from system to system.
  513.  
  514.    Even when such limits might be well beyond the possibility of being
  515. encountered on a particular system, the `g77' run-time environment has
  516. certain built-in limits, usually, but not always, stemming from
  517. intrinsics with inherently limited interfaces.
  518.  
  519.    Currently, the `g77' run-time environment does not generally offer a
  520. less-limiting environment by augmenting the underlying system's own
  521. environment.
  522.  
  523.    Therefore, code written in the GNU Fortran language, while
  524. syntactically and semantically portable, might nevertheless make
  525. non-portable assumptions about the run-time environment--assumptions
  526. that prove to be false for some particular environments.
  527.  
  528.    The GNU Fortran language, the `g77' compiler and run-time
  529. environment, and the `g77' documentation do not yet offer comprehensive
  530. portable work-arounds for such limits, though programmers should be
  531. able to find their own in specific instances.
  532.  
  533.    Not all of the limitations are described in this document.  Some of
  534. the known limitations include:
  535.  
  536. * Menu:
  537.  
  538. * Timer Wraparounds::
  539. * Year 2000 (Y2K) Problems::
  540. * Array Size::
  541. * Character-variable Length::
  542. * Year 10000 (Y10K) Problems::
  543.  
  544. 
  545. File: g77.info,  Node: Timer Wraparounds,  Next: Year 2000 (Y2K) Problems,  Up: Run-time Environment Limits
  546.  
  547. Timer Wraparounds
  548. -----------------
  549.  
  550.    Intrinsics that return values computed from system timers, whether
  551. elapsed (wall-clock) timers, process CPU timers, or other kinds of
  552. timers, are prone to experiencing wrap-around errors (or returning
  553. wrapped-around values from successive calls) due to insufficient ranges
  554. offered by the underlying system's timers.
  555.  
  556.    Some of the symptoms of such behaviors include apparently negative
  557. time being computed for a duration, an extremely short amount of time
  558. being computed for a long duration, and an extremely long amount of
  559. time being computed for a short duration.
  560.  
  561.    See the following for intrinsics known to have potential problems in
  562. these areas on at least some systems: *Note CPU_Time Intrinsic::.,
  563. *Note DTime Intrinsic (function)::., *Note DTime Intrinsic
  564. (subroutine)::., *Note ETime Intrinsic (function)::., *Note ETime
  565. Intrinsic (subroutine)::., *Note MClock Intrinsic::., *Note MClock8
  566. Intrinsic::., *Note Secnds Intrinsic::., *Note Second Intrinsic
  567. (function)::., *Note Second Intrinsic (subroutine)::., *Note
  568. System_Clock Intrinsic::., *Note Time Intrinsic (UNIX)::., *Note Time
  569. Intrinsic (VXT)::., *Note Time8 Intrinsic::..
  570.  
  571. 
  572. File: g77.info,  Node: Year 2000 (Y2K) Problems,  Next: Array Size,  Prev: Timer Wraparounds,  Up: Run-time Environment Limits
  573.  
  574. Year 2000 (Y2K) Problems
  575. ------------------------
  576.  
  577.    While the `g77' compiler itself is believed to be Year-2000 (Y2K)
  578. compliant, some intrinsics are not, and, potentially, some underlying
  579. systems are not, perhaps rendering some Y2K-compliant intrinsics
  580. non-compliant when used on those particular systems.
  581.  
  582.    Fortran code that uses non-Y2K-compliant intrinsics (listed below)
  583. is, itself, almost certainly not compliant, and should be modified to
  584. use Y2K-compliant intrinsics instead.
  585.  
  586.    Fortran code that uses no non-Y2K-compliant intrinsics, but which
  587. currently is running on a non-Y2K-compliant system, can be made more
  588. Y2K compliant by compiling and linking it for use on a new
  589. Y2K-compliant system, such as a new version of an old,
  590. non-Y2K-compliant, system.
  591.  
  592.    Currently, information on Y2K and related issues is being maintained
  593. at `http://www.gnu.org/software/year2000-list.html'.
  594.  
  595.    See the following for intrinsics known to have potential problems in
  596. these areas on at least some systems: *Note Date Intrinsic::., *Note
  597. IDate Intrinsic (VXT)::..
  598.  
  599.    The `libg2c' library shipped with any `g77' that warns about
  600. invocation of a non-Y2K-compliant intrinsic has renamed the `EXTERNAL'
  601. procedure names of those intrinsics.  This is done so that the `libg2c'
  602. implementations of these intrinsics cannot be directly linked to as
  603. `EXTERNAL' names (which normally would avoid the non-Y2K-intrinsic
  604. warning).
  605.  
  606.    The renamed forms of the `EXTERNAL' names of these renamed procedures
  607. may be linked to by appending the string `_y2kbug' to the name of the
  608. procedure in the source code.  For example:
  609.  
  610.      CHARACTER*20 STR
  611.      INTEGER YY, MM, DD
  612.      EXTERNAL DATE_Y2KBUG, VXTIDATE_Y2KBUG
  613.      CALL DATE_Y2KBUG (STR)
  614.      CALL VXTIDATE_Y2KBUG (MM, DD, YY)
  615.  
  616.    (Note that the `EXTERNAL' statement is not actually required, since
  617. the modified names are not recognized as intrinsics by the current
  618. version of `g77'.  But it is shown in this specific case, for purposes
  619. of illustration.)
  620.  
  621.    The renaming of `EXTERNAL' procedure names of these intrinsics
  622. causes unresolved references at link time.  For example, `EXTERNAL
  623. DATE; CALL DATE(STR)' is normally compiled by `g77' as, in C,
  624. `date_(&str, 20);'.  This, in turn, links to the `date_' procedure in
  625. the `libE77' portion of `libg2c', which purposely calls a nonexistent
  626. procedure named `G77_date_y2kbuggy_0'.  The resulting link-time error
  627. is designed, via this name, to encourage the programmer to look up the
  628. index entries to this portion of the `g77' documentation.
  629.  
  630.    Generally, we recommend that the `EXTERNAL' method of invoking
  631. procedures in `libg2c' *not* be used.  When used, some of the
  632. correctness checking normally performed by `g77' is skipped.
  633.  
  634.    In particular, it is probably better to use the `INTRINSIC' method
  635. of invoking non-Y2K-compliant procedures, so anyone compiling the code
  636. can quickly notice the potential Y2K problems (via the warnings
  637. printing by `g77') without having to even look at the code itself.
  638.  
  639.    If there are problems linking `libg2c' to code compiled by `g77'
  640. that involve the string `y2kbug', and these are not explained above,
  641. that probably indicates that a version of `libg2c' older than `g77' is
  642. being linked to, or that the new library is being linked to code
  643. compiled by an older version of `g77'.
  644.  
  645.    That's because, as of the version that warns about non-Y2K-compliant
  646. intrinsic invocation, `g77' references the `libg2c' implementations of
  647. those intrinsics using new names, containing the string `y2kbug'.
  648.  
  649.    So, linking newly-compiled code (invoking one of the intrinsics in
  650. question) to an old library might yield an unresolved reference to
  651. `G77_date_y2kbug_0'.  (The old library calls it `G77_date_0'.)
  652.  
  653.    Similarly, linking previously-compiled code to a new library might
  654. yield an unresolved reference to `G77_vxtidate_0'.  (The new library
  655. calls it `G77_vxtidate_y2kbug_0'.)
  656.  
  657.    The proper fix for the above problems is to obtain the latest
  658. release of `g77' and related products (including `libg2c') and install
  659. them on all systems, then recompile, relink, and install (as
  660. appropriate) all existing Fortran programs.
  661.  
  662.    (Normally, this sort of renaming is steadfastly avoided.  In this
  663. case, however, it seems more important to highlight potential Y2K
  664. problems than to ease the transition of potentially non-Y2K-compliant
  665. code to new versions of `g77' and `libg2c'.)
  666.  
  667. 
  668. File: g77.info,  Node: Array Size,  Next: Character-variable Length,  Prev: Year 2000 (Y2K) Problems,  Up: Run-time Environment Limits
  669.  
  670. Array Size
  671. ----------
  672.  
  673.    Currently, `g77' uses the default `INTEGER' type for array indexes,
  674. which limits the sizes of single-dimension arrays on systems offering a
  675. larger address space than can be addressed by that type.  (That `g77'
  676. puts all arrays in memory could be considered another limitation--it
  677. could use large temporary files--but that decision is left to the
  678. programmer as an implementation choice by most Fortran implementations.)
  679.  
  680.    It is not yet clear whether this limitation never, sometimes, or
  681. always applies to the sizes of multiple-dimension arrays as a whole.
  682.  
  683.    For example, on a system with 64-bit addresses and 32-bit default
  684. `INTEGER', an array with a size greater than can be addressed by a
  685. 32-bit offset can be declared using multiple dimensions.  Such an array
  686. is therefore larger than a single-dimension array can be, on the same
  687. system.
  688.  
  689.    Whether large multiple-dimension arrays are reliably supported
  690. depends mostly on the `gcc' back end (code generator) used by `g77',
  691. and has not yet been fully investigated.
  692.  
  693. 
  694. File: g77.info,  Node: Character-variable Length,  Next: Year 10000 (Y10K) Problems,  Prev: Array Size,  Up: Run-time Environment Limits
  695.  
  696. Character-variable Length
  697. -------------------------
  698.  
  699.    Currently, `g77' uses the default `INTEGER' type for the lengths of
  700. `CHARACTER' variables and array elements.
  701.  
  702.    This means that, for example, a system with a 64-bit address space
  703. and a 32-bit default `INTEGER' type does not, under `g77', support a
  704. `CHARACTER*N' declaration where N is greater than 2147483647.
  705.  
  706. 
  707. File: g77.info,  Node: Year 10000 (Y10K) Problems,  Prev: Character-variable Length,  Up: Run-time Environment Limits
  708.  
  709. Year 10000 (Y10K) Problems
  710. --------------------------
  711.  
  712.    Most intrinsics returning, or computing values based on, date
  713. information are prone to Year-10000 (Y10K) problems, due to supporting
  714. only 4 digits for the year.
  715.  
  716.    See the following for examples: *Note FDate Intrinsic (function)::.,
  717. *Note FDate Intrinsic (subroutine)::., *Note IDate Intrinsic (UNIX)::.,
  718. *Note Time Intrinsic (VXT)::., *Note Date_and_Time Intrinsic::..
  719.  
  720. 
  721. File: g77.info,  Node: Compiler Types,  Next: Compiler Constants,  Prev: Run-time Environment Limits,  Up: Compiler
  722.  
  723. Compiler Types
  724. ==============
  725.  
  726.    Fortran implementations have a fair amount of freedom given them by
  727. the standard as far as how much storage space is used and how much
  728. precision and range is offered by the various types such as
  729. `LOGICAL(KIND=1)', `INTEGER(KIND=1)', `REAL(KIND=1)', `REAL(KIND=2)',
  730. `COMPLEX(KIND=1)', and `CHARACTER'.  Further, many compilers offer
  731. so-called `*N' notation, but the interpretation of N varies across
  732. compilers and target architectures.
  733.  
  734.    The standard requires that `LOGICAL(KIND=1)', `INTEGER(KIND=1)', and
  735. `REAL(KIND=1)' occupy the same amount of storage space, and that
  736. `COMPLEX(KIND=1)' and `REAL(KIND=2)' take twice as much storage space
  737. as `REAL(KIND=1)'.  Further, it requires that `COMPLEX(KIND=1)'
  738. entities be ordered such that when a `COMPLEX(KIND=1)' variable is
  739. storage-associated (such as via `EQUIVALENCE') with a two-element
  740. `REAL(KIND=1)' array named `R', `R(1)' corresponds to the real element
  741. and `R(2)' to the imaginary element of the `COMPLEX(KIND=1)' variable.
  742.  
  743.    (Few requirements as to precision or ranges of any of these are
  744. placed on the implementation, nor is the relationship of storage sizes
  745. of these types to the `CHARACTER' type specified, by the standard.)
  746.  
  747.    `g77' follows the above requirements, warning when compiling a
  748. program requires placement of items in memory that contradict the
  749. requirements of the target architecture.  (For example, a program can
  750. require placement of a `REAL(KIND=2)' on a boundary that is not an even
  751. multiple of its size, but still an even multiple of the size of a
  752. `REAL(KIND=1)' variable.  On some target architectures, using the
  753. canonical mapping of Fortran types to underlying architectural types,
  754. such placement is prohibited by the machine definition or the
  755. Application Binary Interface (ABI) in force for the configuration
  756. defined for building `gcc' and `g77'.  `g77' warns about such
  757. situations when it encounters them.)
  758.  
  759.    `g77' follows consistent rules for configuring the mapping between
  760. Fortran types, including the `*N' notation, and the underlying
  761. architectural types as accessed by a similarly-configured applicable
  762. version of the `gcc' compiler.  These rules offer a widely portable,
  763. consistent Fortran/C environment, although they might well conflict
  764. with the expectations of users of Fortran compilers designed and
  765. written for particular architectures.
  766.  
  767.    These rules are based on the configuration that is in force for the
  768. version of `gcc' built in the same release as `g77' (and which was
  769. therefore used to build both the `g77' compiler components and the
  770. `libg2c' run-time library):
  771.  
  772. `REAL(KIND=1)'
  773.      Same as `float' type.
  774.  
  775. `REAL(KIND=2)'
  776.      Same as whatever floating-point type that is twice the size of a
  777.      `float'--usually, this is a `double'.
  778.  
  779. `INTEGER(KIND=1)'
  780.      Same as an integral type that is occupies the same amount of
  781.      memory storage as `float'--usually, this is either an `int' or a
  782.      `long int'.
  783.  
  784. `LOGICAL(KIND=1)'
  785.      Same `gcc' type as `INTEGER(KIND=1)'.
  786.  
  787. `INTEGER(KIND=2)'
  788.      Twice the size, and usually nearly twice the range, as
  789.      `INTEGER(KIND=1)'--usually, this is either a `long int' or a `long
  790.      long int'.
  791.  
  792. `LOGICAL(KIND=2)'
  793.      Same `gcc' type as `INTEGER(KIND=2)'.
  794.  
  795. `INTEGER(KIND=3)'
  796.      Same `gcc' type as signed `char'.
  797.  
  798. `LOGICAL(KIND=3)'
  799.      Same `gcc' type as `INTEGER(KIND=3)'.
  800.  
  801. `INTEGER(KIND=6)'
  802.      Twice the size, and usually nearly twice the range, as
  803.      `INTEGER(KIND=3)'--usually, this is a `short'.
  804.  
  805. `LOGICAL(KIND=6)'
  806.      Same `gcc' type as `INTEGER(KIND=6)'.
  807.  
  808. `COMPLEX(KIND=1)'
  809.      Two `REAL(KIND=1)' scalars (one for the real part followed by one
  810.      for the imaginary part).
  811.  
  812. `COMPLEX(KIND=2)'
  813.      Two `REAL(KIND=2)' scalars.
  814.  
  815. `NUMERIC-TYPE*N'
  816.      (Where NUMERIC-TYPE is any type other than `CHARACTER'.)  Same as
  817.      whatever `gcc' type occupies N times the storage space of a `gcc'
  818.      `char' item.
  819.  
  820. `DOUBLE PRECISION'
  821.      Same as `REAL(KIND=2)'.
  822.  
  823. `DOUBLE COMPLEX'
  824.      Same as `COMPLEX(KIND=2)'.
  825.  
  826.    Note that the above are proposed correspondences and might change in
  827. future versions of `g77'--avoid writing code depending on them.
  828.  
  829.    Other types supported by `g77' are derived from gcc types such as
  830. `char', `short', `int', `long int', `long long int', `long double', and
  831. so on.  That is, whatever types `gcc' already supports, `g77' supports
  832. now or probably will support in a future version.  The rules for the
  833. `NUMERIC-TYPE*N' notation apply to these types, and new values for
  834. `NUMERIC-TYPE(KIND=N)' will be assigned in a way that encourages
  835. clarity, consistency, and portability.
  836.  
  837. 
  838. File: g77.info,  Node: Compiler Constants,  Next: Compiler Intrinsics,  Prev: Compiler Types,  Up: Compiler
  839.  
  840. Compiler Constants
  841. ==================
  842.  
  843.    `g77' strictly assigns types to *all* constants not documented as
  844. "typeless" (typeless constants including `'1'Z', for example).  Many
  845. other Fortran compilers attempt to assign types to typed constants
  846. based on their context.  This results in hard-to-find bugs, nonportable
  847. code, and is not in the spirit (though it strictly follows the letter)
  848. of the 77 and 90 standards.
  849.  
  850.    `g77' might offer, in a future release, explicit constructs by which
  851. a wider variety of typeless constants may be specified, and/or
  852. user-requested warnings indicating places where `g77' might differ from
  853. how other compilers assign types to constants.
  854.  
  855.    *Note Context-Sensitive Constants::, for more information on this
  856. issue.
  857.  
  858. 
  859. File: g77.info,  Node: Compiler Intrinsics,  Prev: Compiler Constants,  Up: Compiler
  860.  
  861. Compiler Intrinsics
  862. ===================
  863.  
  864.    `g77' offers an ever-widening set of intrinsics.  Currently these
  865. all are procedures (functions and subroutines).
  866.  
  867.    Some of these intrinsics are unimplemented, but their names reserved
  868. to reduce future problems with existing code as they are implemented.
  869. Others are implemented as part of the GNU Fortran language, while yet
  870. others are provided for compatibility with other dialects of Fortran
  871. but are not part of the GNU Fortran language.
  872.  
  873.    To manage these distinctions, `g77' provides intrinsic *groups*, a
  874. facility that is simply an extension of the intrinsic groups provided
  875. by the GNU Fortran language.
  876.  
  877. * Menu:
  878.  
  879. * Intrinsic Groups::  How intrinsics are grouped for easy management.
  880. * Other Intrinsics::  Intrinsics other than those in the GNU
  881.                        Fortran language.
  882.  
  883. 
  884. File: g77.info,  Node: Intrinsic Groups,  Next: Other Intrinsics,  Up: Compiler Intrinsics
  885.  
  886. Intrinsic Groups
  887. ----------------
  888.  
  889.    A given specific intrinsic belongs in one or more groups.  Each
  890. group is deleted, disabled, hidden, or enabled by default or a
  891. command-line option.  The meaning of each term follows.
  892.  
  893. Deleted
  894.      No intrinsics are recognized as belonging to that group.
  895.  
  896. Disabled
  897.      Intrinsics are recognized as belonging to the group, but
  898.      references to them (other than via the `INTRINSIC' statement) are
  899.      disallowed through that group.
  900.  
  901. Hidden
  902.      Intrinsics in that group are recognized and enabled (if
  903.      implemented) *only* if the first mention of the actual name of an
  904.      intrinsic in a program unit is in an `INTRINSIC' statement.
  905.  
  906. Enabled
  907.      Intrinsics in that group are recognized and enabled (if
  908.      implemented).
  909.  
  910.    The distinction between deleting and disabling a group is illustrated
  911. by the following example.  Assume intrinsic `FOO' belongs only to group
  912. `FGR'.  If group `FGR' is deleted, the following program unit will
  913. successfully compile, because `FOO()' will be seen as a reference to an
  914. external function named `FOO':
  915.  
  916.      PRINT *, FOO()
  917.      END
  918.  
  919. If group `FGR' is disabled, compiling the above program will produce
  920. diagnostics, either because the `FOO' intrinsic is improperly invoked
  921. or, if properly invoked, it is not enabled.  To change the above
  922. program so it references an external function `FOO' instead of the
  923. disabled `FOO' intrinsic, add the following line to the top:
  924.  
  925.      EXTERNAL FOO
  926.  
  927. So, deleting a group tells `g77' to pretend as though the intrinsics in
  928. that group do not exist at all, whereas disabling it tells `g77' to
  929. recognize them as (disabled) intrinsics in intrinsic-like contexts.
  930.  
  931.    Hiding a group is like enabling it, but the intrinsic must be first
  932. named in an `INTRINSIC' statement to be considered a reference to the
  933. intrinsic rather than to an external procedure.  This might be the
  934. "safest" way to treat a new group of intrinsics when compiling old
  935. code, because it allows the old code to be generally written as if
  936. those new intrinsics never existed, but to be changed to use them by
  937. inserting `INTRINSIC' statements in the appropriate places.  However,
  938. it should be the goal of development to use `EXTERNAL' for all names of
  939. external procedures that might be intrinsic names.
  940.  
  941.    If an intrinsic is in more than one group, it is enabled if any of
  942. its containing groups are enabled; if not so enabled, it is hidden if
  943. any of its containing groups are hidden; if not so hidden, it is
  944. disabled if any of its containing groups are disabled; if not so
  945. disabled, it is deleted.  This extra complication is necessary because
  946. some intrinsics, such as `IBITS', belong to more than one group, and
  947. hence should be enabled if any of the groups to which they belong are
  948. enabled, and so on.
  949.  
  950.    The groups are:
  951.  
  952. `badu77'
  953.      UNIX intrinsics having inappropriate forms (usually functions that
  954.      have intended side effects).
  955.  
  956. `gnu'
  957.      Intrinsics the GNU Fortran language supports that are extensions to
  958.      the Fortran standards (77 and 90).
  959.  
  960. `f2c'
  961.      Intrinsics supported by AT&T's `f2c' converter and/or `libf2c'.
  962.  
  963. `f90'
  964.      Fortran 90 intrinsics.
  965.  
  966. `mil'
  967.      MIL-STD 1753 intrinsics (`MVBITS', `IAND', `BTEST', and so on).
  968.  
  969. `unix'
  970.      UNIX intrinsics (`IARGC', `EXIT', `ERF', and so on).
  971.  
  972. `vxt'
  973.      VAX/VMS FORTRAN (current as of v4) intrinsics.
  974.  
  975. 
  976. File: g77.info,  Node: Other Intrinsics,  Prev: Intrinsic Groups,  Up: Compiler Intrinsics
  977.  
  978. Other Intrinsics
  979. ----------------
  980.  
  981.    `g77' supports intrinsics other than those in the GNU Fortran
  982. language proper.  This set of intrinsics is described below.
  983.  
  984.    (Note that the empty lines appearing in the menu below are not
  985. intentional--they result from a bug in the `makeinfo' program.)
  986.  
  987. * Menu:
  988.  
  989.  
  990. * ACosD Intrinsic::     (Reserved for future use.)
  991.  
  992. * AIMax0 Intrinsic::    (Reserved for future use.)
  993. * AIMin0 Intrinsic::    (Reserved for future use.)
  994.  
  995. * AJMax0 Intrinsic::    (Reserved for future use.)
  996. * AJMin0 Intrinsic::    (Reserved for future use.)
  997.  
  998. * ASinD Intrinsic::     (Reserved for future use.)
  999.  
  1000. * ATan2D Intrinsic::    (Reserved for future use.)
  1001. * ATanD Intrinsic::     (Reserved for future use.)
  1002.  
  1003. * BITest Intrinsic::    (Reserved for future use.)
  1004.  
  1005. * BJTest Intrinsic::    (Reserved for future use.)
  1006.  
  1007. * CDAbs Intrinsic::     Absolute value (archaic).
  1008. * CDCos Intrinsic::     Cosine (archaic).
  1009. * CDExp Intrinsic::     Exponential (archaic).
  1010. * CDLog Intrinsic::     Natural logarithm (archaic).
  1011. * CDSin Intrinsic::     Sine (archaic).
  1012. * CDSqRt Intrinsic::    Square root (archaic).
  1013.  
  1014. * ChDir Intrinsic (function):: Change directory.
  1015.  
  1016. * ChMod Intrinsic (function):: Change file modes.
  1017.  
  1018. * CosD Intrinsic::      (Reserved for future use.)
  1019.  
  1020. * DACosD Intrinsic::    (Reserved for future use.)
  1021.  
  1022. * DASinD Intrinsic::    (Reserved for future use.)
  1023.  
  1024. * DATan2D Intrinsic::   (Reserved for future use.)
  1025. * DATanD Intrinsic::    (Reserved for future use.)
  1026. * Date Intrinsic::      Get current date as dd-Mon-yy.
  1027.  
  1028. * DbleQ Intrinsic::     (Reserved for future use.)
  1029.  
  1030. * DCmplx Intrinsic::    Construct `COMPLEX(KIND=2)' value.
  1031. * DConjg Intrinsic::    Complex conjugate (archaic).
  1032.  
  1033. * DCosD Intrinsic::     (Reserved for future use.)
  1034.  
  1035. * DFloat Intrinsic::    Conversion (archaic).
  1036.  
  1037. * DFlotI Intrinsic::    (Reserved for future use.)
  1038. * DFlotJ Intrinsic::    (Reserved for future use.)
  1039.  
  1040. * DImag Intrinsic::     Convert/extract imaginary part of complex (archaic).
  1041.  
  1042. * DReal Intrinsic::     Convert value to type `REAL(KIND=2)'.
  1043.  
  1044. * DSinD Intrinsic::     (Reserved for future use.)
  1045.  
  1046. * DTanD Intrinsic::     (Reserved for future use.)
  1047.  
  1048. * DTime Intrinsic (function):: Get elapsed time since last time.
  1049.  
  1050. * FGet Intrinsic (function):: Read a character from unit 5 stream-wise.
  1051.  
  1052. * FGetC Intrinsic (function):: Read a character stream-wise.
  1053.  
  1054. * FloatI Intrinsic::    (Reserved for future use.)
  1055. * FloatJ Intrinsic::    (Reserved for future use.)
  1056.  
  1057. * FPut Intrinsic (function):: Write a character to unit 6 stream-wise.
  1058.  
  1059. * FPutC Intrinsic (function):: Write a character stream-wise.
  1060.  
  1061. * IDate Intrinsic (VXT):: Get local time info (VAX/VMS).
  1062.  
  1063. * IIAbs Intrinsic::     (Reserved for future use.)
  1064. * IIAnd Intrinsic::     (Reserved for future use.)
  1065. * IIBClr Intrinsic::    (Reserved for future use.)
  1066. * IIBits Intrinsic::    (Reserved for future use.)
  1067. * IIBSet Intrinsic::    (Reserved for future use.)
  1068. * IIDiM Intrinsic::     (Reserved for future use.)
  1069. * IIDInt Intrinsic::    (Reserved for future use.)
  1070. * IIDNnt Intrinsic::    (Reserved for future use.)
  1071. * IIEOr Intrinsic::     (Reserved for future use.)
  1072. * IIFix Intrinsic::     (Reserved for future use.)
  1073. * IInt Intrinsic::      (Reserved for future use.)
  1074. * IIOr Intrinsic::      (Reserved for future use.)
  1075. * IIQint Intrinsic::    (Reserved for future use.)
  1076. * IIQNnt Intrinsic::    (Reserved for future use.)
  1077. * IIShftC Intrinsic::   (Reserved for future use.)
  1078. * IISign Intrinsic::    (Reserved for future use.)
  1079.  
  1080. * IMax0 Intrinsic::     (Reserved for future use.)
  1081. * IMax1 Intrinsic::     (Reserved for future use.)
  1082. * IMin0 Intrinsic::     (Reserved for future use.)
  1083. * IMin1 Intrinsic::     (Reserved for future use.)
  1084. * IMod Intrinsic::      (Reserved for future use.)
  1085.  
  1086. * INInt Intrinsic::     (Reserved for future use.)
  1087. * INot Intrinsic::      (Reserved for future use.)
  1088.  
  1089. * IZExt Intrinsic::     (Reserved for future use.)
  1090. * JIAbs Intrinsic::     (Reserved for future use.)
  1091. * JIAnd Intrinsic::     (Reserved for future use.)
  1092. * JIBClr Intrinsic::    (Reserved for future use.)
  1093. * JIBits Intrinsic::    (Reserved for future use.)
  1094. * JIBSet Intrinsic::    (Reserved for future use.)
  1095. * JIDiM Intrinsic::     (Reserved for future use.)
  1096. * JIDInt Intrinsic::    (Reserved for future use.)
  1097. * JIDNnt Intrinsic::    (Reserved for future use.)
  1098. * JIEOr Intrinsic::     (Reserved for future use.)
  1099. * JIFix Intrinsic::     (Reserved for future use.)
  1100. * JInt Intrinsic::      (Reserved for future use.)
  1101. * JIOr Intrinsic::      (Reserved for future use.)
  1102. * JIQint Intrinsic::    (Reserved for future use.)
  1103. * JIQNnt Intrinsic::    (Reserved for future use.)
  1104. * JIShft Intrinsic::    (Reserved for future use.)
  1105. * JIShftC Intrinsic::   (Reserved for future use.)
  1106. * JISign Intrinsic::    (Reserved for future use.)
  1107. * JMax0 Intrinsic::     (Reserved for future use.)
  1108. * JMax1 Intrinsic::     (Reserved for future use.)
  1109. * JMin0 Intrinsic::     (Reserved for future use.)
  1110. * JMin1 Intrinsic::     (Reserved for future use.)
  1111. * JMod Intrinsic::      (Reserved for future use.)
  1112. * JNInt Intrinsic::     (Reserved for future use.)
  1113. * JNot Intrinsic::      (Reserved for future use.)
  1114. * JZExt Intrinsic::     (Reserved for future use.)
  1115.  
  1116. * Kill Intrinsic (function):: Signal a process.
  1117.  
  1118. * Link Intrinsic (function):: Make hard link in file system.
  1119.  
  1120. * QAbs Intrinsic::      (Reserved for future use.)
  1121. * QACos Intrinsic::     (Reserved for future use.)
  1122. * QACosD Intrinsic::    (Reserved for future use.)
  1123. * QASin Intrinsic::     (Reserved for future use.)
  1124. * QASinD Intrinsic::    (Reserved for future use.)
  1125. * QATan Intrinsic::     (Reserved for future use.)
  1126. * QATan2 Intrinsic::    (Reserved for future use.)
  1127. * QATan2D Intrinsic::   (Reserved for future use.)
  1128. * QATanD Intrinsic::    (Reserved for future use.)
  1129. * QCos Intrinsic::      (Reserved for future use.)
  1130. * QCosD Intrinsic::     (Reserved for future use.)
  1131. * QCosH Intrinsic::     (Reserved for future use.)
  1132. * QDiM Intrinsic::      (Reserved for future use.)
  1133. * QExp Intrinsic::      (Reserved for future use.)
  1134. * QExt Intrinsic::      (Reserved for future use.)
  1135. * QExtD Intrinsic::     (Reserved for future use.)
  1136. * QFloat Intrinsic::    (Reserved for future use.)
  1137. * QInt Intrinsic::      (Reserved for future use.)
  1138. * QLog Intrinsic::      (Reserved for future use.)
  1139. * QLog10 Intrinsic::    (Reserved for future use.)
  1140. * QMax1 Intrinsic::     (Reserved for future use.)
  1141. * QMin1 Intrinsic::     (Reserved for future use.)
  1142. * QMod Intrinsic::      (Reserved for future use.)
  1143. * QNInt Intrinsic::     (Reserved for future use.)
  1144. * QSin Intrinsic::      (Reserved for future use.)
  1145. * QSinD Intrinsic::     (Reserved for future use.)
  1146. * QSinH Intrinsic::     (Reserved for future use.)
  1147. * QSqRt Intrinsic::     (Reserved for future use.)
  1148. * QTan Intrinsic::      (Reserved for future use.)
  1149. * QTanD Intrinsic::     (Reserved for future use.)
  1150. * QTanH Intrinsic::     (Reserved for future use.)
  1151.  
  1152. * Rename Intrinsic (function):: Rename file.
  1153.  
  1154. * Secnds Intrinsic::    Get local time offset since midnight.
  1155.  
  1156. * Signal Intrinsic (function):: Muck with signal handling.
  1157.  
  1158. * SinD Intrinsic::      (Reserved for future use.)
  1159.  
  1160. * SnglQ Intrinsic::     (Reserved for future use.)
  1161.  
  1162. * SymLnk Intrinsic (function):: Make symbolic link in file system.
  1163.  
  1164. * System Intrinsic (function):: Invoke shell (system) command.
  1165.  
  1166. * TanD Intrinsic::      (Reserved for future use.)
  1167.  
  1168. * Time Intrinsic (VXT):: Get the time as a character value.
  1169.  
  1170. * UMask Intrinsic (function):: Set file creation permissions mask.
  1171.  
  1172. * Unlink Intrinsic (function):: Unlink file.
  1173.  
  1174. * ZExt Intrinsic::      (Reserved for future use.)
  1175.  
  1176. 
  1177. File: g77.info,  Node: ACosD Intrinsic,  Next: AIMax0 Intrinsic,  Up: Other Intrinsics
  1178.  
  1179. ACosD Intrinsic
  1180. ...............
  1181.  
  1182.    This intrinsic is not yet implemented.  The name is, however,
  1183. reserved as an intrinsic.  Use `EXTERNAL ACosD' to use this name for an
  1184. external procedure.
  1185.  
  1186. 
  1187. File: g77.info,  Node: AIMax0 Intrinsic,  Next: AIMin0 Intrinsic,  Prev: ACosD Intrinsic,  Up: Other Intrinsics
  1188.  
  1189. AIMax0 Intrinsic
  1190. ................
  1191.  
  1192.    This intrinsic is not yet implemented.  The name is, however,
  1193. reserved as an intrinsic.  Use `EXTERNAL AIMax0' to use this name for an
  1194. external procedure.
  1195.  
  1196. 
  1197. File: g77.info,  Node: AIMin0 Intrinsic,  Next: AJMax0 Intrinsic,  Prev: AIMax0 Intrinsic,  Up: Other Intrinsics
  1198.  
  1199. AIMin0 Intrinsic
  1200. ................
  1201.  
  1202.    This intrinsic is not yet implemented.  The name is, however,
  1203. reserved as an intrinsic.  Use `EXTERNAL AIMin0' to use this name for an
  1204. external procedure.
  1205.  
  1206. 
  1207. File: g77.info,  Node: AJMax0 Intrinsic,  Next: AJMin0 Intrinsic,  Prev: AIMin0 Intrinsic,  Up: Other Intrinsics
  1208.  
  1209. AJMax0 Intrinsic
  1210. ................
  1211.  
  1212.    This intrinsic is not yet implemented.  The name is, however,
  1213. reserved as an intrinsic.  Use `EXTERNAL AJMax0' to use this name for an
  1214. external procedure.
  1215.  
  1216. 
  1217. File: g77.info,  Node: AJMin0 Intrinsic,  Next: ASinD Intrinsic,  Prev: AJMax0 Intrinsic,  Up: Other Intrinsics
  1218.  
  1219. AJMin0 Intrinsic
  1220. ................
  1221.  
  1222.    This intrinsic is not yet implemented.  The name is, however,
  1223. reserved as an intrinsic.  Use `EXTERNAL AJMin0' to use this name for an
  1224. external procedure.
  1225.  
  1226. 
  1227. File: g77.info,  Node: ASinD Intrinsic,  Next: ATan2D Intrinsic,  Prev: AJMin0 Intrinsic,  Up: Other Intrinsics
  1228.  
  1229. ASinD Intrinsic
  1230. ...............
  1231.  
  1232.    This intrinsic is not yet implemented.  The name is, however,
  1233. reserved as an intrinsic.  Use `EXTERNAL ASinD' to use this name for an
  1234. external procedure.
  1235.  
  1236. 
  1237. File: g77.info,  Node: ATan2D Intrinsic,  Next: ATanD Intrinsic,  Prev: ASinD Intrinsic,  Up: Other Intrinsics
  1238.  
  1239. ATan2D Intrinsic
  1240. ................
  1241.  
  1242.    This intrinsic is not yet implemented.  The name is, however,
  1243. reserved as an intrinsic.  Use `EXTERNAL ATan2D' to use this name for an
  1244. external procedure.
  1245.  
  1246. 
  1247. File: g77.info,  Node: ATanD Intrinsic,  Next: BITest Intrinsic,  Prev: ATan2D Intrinsic,  Up: Other Intrinsics
  1248.  
  1249. ATanD Intrinsic
  1250. ...............
  1251.  
  1252.    This intrinsic is not yet implemented.  The name is, however,
  1253. reserved as an intrinsic.  Use `EXTERNAL ATanD' to use this name for an
  1254. external procedure.
  1255.  
  1256. 
  1257. File: g77.info,  Node: BITest Intrinsic,  Next: BJTest Intrinsic,  Prev: ATanD Intrinsic,  Up: Other Intrinsics
  1258.  
  1259. BITest Intrinsic
  1260. ................
  1261.  
  1262.    This intrinsic is not yet implemented.  The name is, however,
  1263. reserved as an intrinsic.  Use `EXTERNAL BITest' to use this name for an
  1264. external procedure.
  1265.  
  1266. 
  1267. File: g77.info,  Node: BJTest Intrinsic,  Next: CDAbs Intrinsic,  Prev: BITest Intrinsic,  Up: Other Intrinsics
  1268.  
  1269. BJTest Intrinsic
  1270. ................
  1271.  
  1272.    This intrinsic is not yet implemented.  The name is, however,
  1273. reserved as an intrinsic.  Use `EXTERNAL BJTest' to use this name for an
  1274. external procedure.
  1275.  
  1276. 
  1277. File: g77.info,  Node: CDAbs Intrinsic,  Next: CDCos Intrinsic,  Prev: BJTest Intrinsic,  Up: Other Intrinsics
  1278.  
  1279. CDAbs Intrinsic
  1280. ...............
  1281.  
  1282.      CDAbs(A)
  1283.  
  1284. CDAbs: `REAL(KIND=2)' function.
  1285.  
  1286. A: `COMPLEX(KIND=2)'; scalar; INTENT(IN).
  1287.  
  1288. Intrinsic groups: `f2c', `vxt'.
  1289.  
  1290. Description:
  1291.  
  1292.    Archaic form of `ABS()' that is specific to one type for A.  *Note
  1293. Abs Intrinsic::.
  1294.  
  1295. 
  1296. File: g77.info,  Node: CDCos Intrinsic,  Next: CDExp Intrinsic,  Prev: CDAbs Intrinsic,  Up: Other Intrinsics
  1297.  
  1298. CDCos Intrinsic
  1299. ...............
  1300.  
  1301.      CDCos(X)
  1302.  
  1303. CDCos: `COMPLEX(KIND=2)' function.
  1304.  
  1305. X: `COMPLEX(KIND=2)'; scalar; INTENT(IN).
  1306.  
  1307. Intrinsic groups: `f2c', `vxt'.
  1308.  
  1309. Description:
  1310.  
  1311.    Archaic form of `COS()' that is specific to one type for X.  *Note
  1312. Cos Intrinsic::.
  1313.  
  1314. 
  1315. File: g77.info,  Node: CDExp Intrinsic,  Next: CDLog Intrinsic,  Prev: CDCos Intrinsic,  Up: Other Intrinsics
  1316.  
  1317. CDExp Intrinsic
  1318. ...............
  1319.  
  1320.      CDExp(X)
  1321.  
  1322. CDExp: `COMPLEX(KIND=2)' function.
  1323.  
  1324. X: `COMPLEX(KIND=2)'; scalar; INTENT(IN).
  1325.  
  1326. Intrinsic groups: `f2c', `vxt'.
  1327.  
  1328. Description:
  1329.  
  1330.    Archaic form of `EXP()' that is specific to one type for X.  *Note
  1331. Exp Intrinsic::.
  1332.  
  1333. 
  1334. File: g77.info,  Node: CDLog Intrinsic,  Next: CDSin Intrinsic,  Prev: CDExp Intrinsic,  Up: Other Intrinsics
  1335.  
  1336. CDLog Intrinsic
  1337. ...............
  1338.  
  1339.      CDLog(X)
  1340.  
  1341. CDLog: `COMPLEX(KIND=2)' function.
  1342.  
  1343. X: `COMPLEX(KIND=2)'; scalar; INTENT(IN).
  1344.  
  1345. Intrinsic groups: `f2c', `vxt'.
  1346.  
  1347. Description:
  1348.  
  1349.    Archaic form of `LOG()' that is specific to one type for X.  *Note
  1350. Log Intrinsic::.
  1351.  
  1352. 
  1353. File: g77.info,  Node: CDSin Intrinsic,  Next: CDSqRt Intrinsic,  Prev: CDLog Intrinsic,  Up: Other Intrinsics
  1354.  
  1355. CDSin Intrinsic
  1356. ...............
  1357.  
  1358.      CDSin(X)
  1359.  
  1360. CDSin: `COMPLEX(KIND=2)' function.
  1361.  
  1362. X: `COMPLEX(KIND=2)'; scalar; INTENT(IN).
  1363.  
  1364. Intrinsic groups: `f2c', `vxt'.
  1365.  
  1366. Description:
  1367.  
  1368.    Archaic form of `SIN()' that is specific to one type for X.  *Note
  1369. Sin Intrinsic::.
  1370.  
  1371. 
  1372. File: g77.info,  Node: CDSqRt Intrinsic,  Next: ChDir Intrinsic (function),  Prev: CDSin Intrinsic,  Up: Other Intrinsics
  1373.  
  1374. CDSqRt Intrinsic
  1375. ................
  1376.  
  1377.      CDSqRt(X)
  1378.  
  1379. CDSqRt: `COMPLEX(KIND=2)' function.
  1380.  
  1381. X: `COMPLEX(KIND=2)'; scalar; INTENT(IN).
  1382.  
  1383. Intrinsic groups: `f2c', `vxt'.
  1384.  
  1385. Description:
  1386.  
  1387.    Archaic form of `SQRT()' that is specific to one type for X.  *Note
  1388. SqRt Intrinsic::.
  1389.  
  1390.